﻿using BoilerplateWPF.Enums;
using BoilerplateWPF.Helpers;
using BoilerplateWPF.Models;
using BoilerplateWPF.Utils;
using BoilerplateWPF.Views;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace BoilerplateWPF.ViewModels
{
    public class ShellViewModel : ObservableObject
    {
        private UserModel _currentUser; // 当前登录用户
        private string _maximizeIconPath; // 最大化按钮的图标路径
        private UIElement _mainContent; // 主要内容区域 显示的页面 UserControl 也可以

        #region 字典 - 页面切换用
        // 缓存字典：用于存储需要缓存的页面实例
        private readonly Dictionary<string, UIElement> _cachedPages = new();

        // 页面配置信息 - 根据实际需求调整页面类型
        private readonly Dictionary<string, PageInfo> _pageConfigs = new()
        {
            { "Home", new PageInfo("Home", PageType.Simple, () => new HomePage()) },
            { "Devices", new PageInfo("Devices", PageType.Cached, () => new DevicesPage()) },
            { "Alerts", new PageInfo("Alerts", PageType.Simple, () => new AlertsPage()) },
            { "Products", new PageInfo("Products", PageType.Cached, () => new ProductsPage()) },
            { "Settings", new PageInfo("Settings", PageType.Singleton, () => new SettingsPage()) }
        };

        // 全部单例模式下可以简化为：
        private readonly Dictionary<string, Func<UIElement>> _pageFactories = new()
        {
            { "Home", () => new HomePage() },
            { "Devices", () => new DevicesPage() },
            { "Alerts", () => new AlertsPage() },
            { "Products", () => new ProductsPage() },
            { "Settings", () => new SettingsPage() }
        };
        #endregion

        public UIElement MainContent
        {
            get => _mainContent;
            set => SetProperty(ref _mainContent, value);
        }

        public string UserName
        {
            get => _currentUser.UserName;
            set { _currentUser.UserName = value; RaisePropertyChanged(); }
        }

        // 字母头像 计算属性
        public string UserInitials => string.IsNullOrEmpty(UserName) ? "?" : new string(UserName.Split(' ').Select(s => s[0]).ToArray()).ToUpper();

        public string MaximizeIconPath
        {
            get => _maximizeIconPath;
            set => SetProperty(ref _maximizeIconPath, value);
        }

        public ICommand WindowMinCommand { get; } // 窗口最小化
        public ICommand WindowMaxCommand { get; } // 窗口最大化
        public ICommand ExitCommand { get; } // 退出程序
        public ICommand NavigateCommand { get; } // 页面切换

        public ShellViewModel(UserModel user)
        {
            // 当前登录用户
            _currentUser = user;

            // 初始化命令对象
            WindowMinCommand = new RelayCommand(ExecuteWindowMin);
            WindowMaxCommand = new RelayCommand(ExecuteWindowMax);
            ExitCommand = new RelayCommand(ExecuteExit);
            NavigateCommand = new RelayCommand<string>(ExecuteNavigate);

            // 设置默认值
            UpdateMaximizeIcon(false); // 初始化图标（默认显示最大化图标）
            NavigateToPageSingleton("Home"); // 设置默认页面 三选一
        }

        #region 导航命令执行 三选一
        /// <summary>
        /// 导航命令执行
        /// </summary>
        private void ExecuteNavigate(object parameter)
        {
            if (parameter is string pageKey)
            {
                // 三选一   全部使用new   混合(new 缓存 单例)   全部使用单例
                //NavigateToPage(pageKey);
                //NavigateToPageMix(pageKey);
                NavigateToPageSingleton(pageKey);

            }
        }

        /// <summary>
        /// 策略1：全部新建 导航到指定页面 每次都会创建新实例 无法保持用户操作状态
        /// </summary>
        private void NavigateToPage(string pageKey)
        {
            MainContent = pageKey switch
            {
                "Home" => new HomePage(),
                "Devices" => new DevicesPage(),
                "Alerts" => new AlertsPage(),
                "Products" => new ProductsPage(),
                "Settings" => new SettingsPage(),
                _ => new HomePage() // 默认页面
            };
        }

        /// <summary>
        /// 策略2：混合模式 智能导航方法 - 根据页面类型选择策略 - new 缓存 单例
        /// </summary>
        private void NavigateToPageMix(string pageKey)
        {
            if (!_pageConfigs.TryGetValue(pageKey, out var pageInfo))
            {
                // 如果页面未配置，使用默认页面
                MainContent = new HomePage();
                return;
            }

            MainContent = pageInfo.Type switch
            {
                PageType.Simple => CreateSimplePage(pageInfo),
                PageType.Cached => GetOrCreateCachedPage(pageInfo),
                PageType.Singleton => GetSingletonPage(pageInfo),
                _ => CreateSimplePage(pageInfo)
            };
        }

        /// <summary>
        /// 创建简单页面 - 每次新建实例
        /// </summary>
        private UIElement CreateSimplePage(PageInfo pageInfo)
        {
            Debug.WriteLine($"创建新实例: {pageInfo.Key}");
            return pageInfo.CreateFunction();
        }

        /// <summary>
        /// 获取或创建缓存页面 - 复用实例
        /// </summary>
        private UIElement GetOrCreateCachedPage(PageInfo pageInfo)
        {
            if (_cachedPages.TryGetValue(pageInfo.Key, out var cachedPage))
            {
                Debug.WriteLine($"使用缓存实例: {pageInfo.Key}");
                return cachedPage;
            }

            Debug.WriteLine($"创建并缓存: {pageInfo.Key}");
            var newPage = pageInfo.CreateFunction();
            _cachedPages[pageInfo.Key] = newPage;
            return newPage;
        }

        /// <summary>
        /// 获取单例页面 - 始终使用同一个实例
        /// </summary>
        private UIElement GetSingletonPage(PageInfo pageInfo)
        {
            // 为每个单例页面使用固定的键名
            string singletonKey = $"Singleton_{pageInfo.Key}";

            if (_cachedPages.TryGetValue(singletonKey, out var singletonPage))
            {
                Debug.WriteLine($"使用单例实例: {pageInfo.Key}");
                return singletonPage;
            }

            Debug.WriteLine($"创建单例: {pageInfo.Key}");
            var newPage = pageInfo.CreateFunction();
            _cachedPages[singletonKey] = newPage;
            return newPage;
        }

        // 策略3：全部单例（使用Singleton_前缀版本）
        private void NavigateToPageSingleton(string pageKey)
        {
            // 先检查请求的页面是否配置
            if (!_pageFactories.ContainsKey(pageKey))
            {
                // 如果页面未配置，使用默认页面Home
                Debug.WriteLine($"警告: 页面 {pageKey} 未配置，导航至默认页面 Home");
                pageKey = "Home"; // 直接使用硬编码的默认值
            }

            // 获取单例页面实例并设置为主内容
            MainContent = GetOrCreateSingletonPage(pageKey);
        }

        /// <summary>
        /// 获取或创建单例页面 - 统一的单例获取方法
        /// </summary>
        private UIElement GetOrCreateSingletonPage(string pageKey)
        {
            // 为每个单例页面使用固定的键名
            string singletonKey = $"Singleton_{pageKey}";

            // 存在则返回
            if (_cachedPages.TryGetValue(singletonKey, out var singletonPage))
            {
                Debug.WriteLine($"使用单例实例: {pageKey}");
                return singletonPage;
            }

            try
            {
                // 创建新实例
                Debug.WriteLine($"创建单例: {pageKey}");
                var newPage = _pageFactories[pageKey](); // 直接调用方法 因为前面已经验证过
                _cachedPages[singletonKey] = newPage;
                return newPage;
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"创建页面 {pageKey} 失败: {ex.Message}");
                // 尝试返回Home页作为fallback
                if (pageKey != "Home" && _pageFactories.ContainsKey("Home"))
                {
                    return GetOrCreateSingletonPage("Home");
                }
                throw; // 如果连Home页都创建失败，只能抛出异常
            }
        }

        /// <summary>
        /// 清理页面缓存 大概率用不到
        /// </summary>
        public void ClearPageCache(bool clearAll = true, string specificPage = null)
        {
            if (clearAll)
            {
                _cachedPages.Clear();
                Debug.WriteLine("所有页面缓存已清理");
            }
            else if (specificPage != null && _pageFactories.ContainsKey(specificPage))
            {
                var keyToRemove = $"Singleton_{specificPage}";
                _cachedPages.Remove(keyToRemove);
                Debug.WriteLine($"页面 {specificPage} 缓存已清理");
            }
        }
        #endregion

        #region 右上角 三个控制按钮
        /// <summary>
        /// 窗口最小化
        /// </summary>
        private void ExecuteWindowMin(object obj)
        {
            if (obj is Window window) // 类型转换
            {
                window.WindowState = WindowState.Minimized;
            }
        }

        /// <summary>
        /// 窗口最大化
        /// </summary>
        private void ExecuteWindowMax(object obj)
        {
            if (obj is Window window)
            {
                if (window.WindowState == WindowState.Maximized)
                {
                    // 如果已经是最大化，就还原
                    window.WindowState = WindowState.Normal;
                    UpdateMaximizeIcon(false); // 更新为最大化图标
                }
                else
                {
                    // 如果是正常状态，就最大化
                    window.WindowState = WindowState.Maximized;
                    UpdateMaximizeIcon(true); // 更新为还原图标
                }
            }
        }

        /// <summary>
        /// 窗口最大化，更新图标封装
        /// </summary>
        private void UpdateMaximizeIcon(bool isMaximized)
        {
            if (isMaximized)
            {
                // 已最大化时显示"还原"图标
                MaximizeIconPath = "pack://application:,,,/BoilerplateWPF;component/Images/收起文本域_collapse-text-input.svg";
            }
            else
            {
                // 未最大化时显示"最大化"图标
                MaximizeIconPath = "pack://application:,,,/BoilerplateWPF;component/Images/展开文本域_expand-text-input.svg";
            }
        }

        /// <summary>
        /// 退出程序
        /// </summary>
        private void ExecuteExit(object obj)
        {
            if (MsgBoxHelper.ConfirmYesNo("确定要退出程序吗？"))
                Application.Current.Shutdown();
        }
        #endregion


    }
}
